﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace CacheAccess
{

    /// <summary>
    /// 带多个键的字典
    /// </summary>
    /// <typeparam name="TKey">键</typeparam>
    /// <typeparam name="TValue">值</typeparam>
    public class MutilDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        #region 数据字典的声明
        private readonly object SyncRoot = new object();
        private readonly Dictionary<TKey, TValue> stDictionary = new Dictionary<TKey, TValue>();
        #endregion

        #region  保存单个实例对象
        /// <summary>
        /// 向泛型里面添加键值对
        /// </summary>
        /// <param name="key">键</param>
        /// <param name="value">键所对应的值</param>
        public void Add(TKey key, TValue value)
        {
            lock (SyncRoot)
            {
                stDictionary.Add(key, value);
            }
        }
        /// <summary>
        /// 这个是判断是不是存在这个键 
        /// </summary>
        /// <param name="key">需要判断的键</param>
        /// <returns></returns>
        public bool ContainsKey(TKey key)
        {
            return stDictionary.ContainsKey(key);
        }
        //返回所有集合对象
        public ICollection<TKey> Keys
        {
            get
            {
                lock (SyncRoot)
                {
                    return stDictionary.Keys;
                }
            }
        }
        /// <summary>
        /// 根据一个键删除这个键值对
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Remove(TKey key)
        {
            lock (SyncRoot)
            {
                return stDictionary.Remove(key);
            }
        }
        /// <summary>
        /// 获取与指定的键相关联的值。 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns>out 导致参数通过引用来传递</returns>
        public bool TryGetValue(TKey key, out TValue value)
        {
            lock (SyncRoot)
            {
                return stDictionary.TryGetValue(key, out value);
            }
        }
        /// <summary>
        /// 定义所有非泛型集合的大小、枚举数和同步方法。
        /// </summary>
        public ICollection<TValue> Values
        {
            get
            {
                lock (SyncRoot)
                {
                    return stDictionary.Values;
                }
            }
        }
        //通过键得到这个建下面的初始值
        public TValue this[TKey key]
        {
            get { return stDictionary[key]; }
            set
            {
                lock (SyncRoot)
                {

                    stDictionary[key] = value;
                }
            }
        }
        #endregion

        #region 保存多个对象集合
        public void Add(KeyValuePair<TKey, TValue> Item)
        {
            lock (SyncRoot)
            {
                ((ICollection<KeyValuePair<TKey, TValue>>)stDictionary).Add(Item);
            }
        }
        //清空集合里面的数据
        public void Clear()
        {
            lock (SyncRoot)
            {
                stDictionary.Clear();
            }
        }
        //看这个元素是不是存在于这个集合中
        public bool Contains(KeyValuePair<TKey, TValue> Item)
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)stDictionary).Contains(Item);
        }
        //将当前一维Array 的所有元素复制到指定的一维Array 中（从指定的目标Array 索引开始）。索引指定为32 位整数
        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int nArrayIndex)
        {
            lock (SyncRoot)
            {
                ((ICollection<KeyValuePair<TKey, TValue>>)stDictionary).CopyTo(array, nArrayIndex);
            }
        }
        //集合的数量
        public int Count
        {
            get { return stDictionary.Count; }
        }
        //是不是只读
        public bool IsReadOnly
        {
            get { return false; }
        }
        public bool Remove(KeyValuePair<TKey, TValue> Item)
        {
            lock (SyncRoot)
            {
                return ((ICollection<KeyValuePair<TKey, TValue>>)stDictionary).Remove(Item);
            }
        }
        //返回这个对象既不是集合对象，也不是集合里面的元素对象，返回的是一个独立的对象，通过这个对象可以访问集合里面的每一个元素
        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return ((ICollection<KeyValuePair<TKey, TValue>>)stDictionary).GetEnumerator();
        }
        //返回这个对象既不是集合对象，也不是集合里面的元素对象，返回的是一个独立的对象，通过这个对象可以访问集合里面的每一个元素
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)stDictionary).GetEnumerator();
        }
        #endregion
    }
}
